             package com.java.diagnostics.visualizer.gc.i5classic.parser;
             
             import com.java.diagnostics.visualizer.data.DataLevel;
             import com.java.diagnostics.visualizer.data.SourceData;
             import com.java.diagnostics.visualizer.data.TupleData;
             import com.java.diagnostics.visualizer.data.TupleDataBuilder;
             import com.java.diagnostics.visualizer.data.axes.AxisPair;
             import com.java.diagnostics.visualizer.data.axes.XDataAxis;
             import com.java.diagnostics.visualizer.data.axes.YDataAxis;
             import com.java.diagnostics.visualizer.exceptions.GCAndMemoryVisualizerException;
             import com.java.diagnostics.visualizer.factory.DataFactory;
             import com.java.diagnostics.visualizer.factory.SourceDataFactory;
             import com.java.diagnostics.visualizer.gc.i5support.util.Messages;
             import com.java.diagnostics.visualizer.impl.factory.LogFactory;
             import com.java.diagnostics.visualizer.metadata.TupleMetaData;
             import com.java.diagnostics.visualizer.metadata.TupleMetaData.TableField;
             import com.java.diagnostics.visualizer.metadata.TupleMetaData.TableType;
             import com.java.diagnostics.visualizer.parser.vgc.VGCPlainTextParser;
             import com.java.diagnostics.visualizer.parser.vgc.constants.VGCAxes;
             import com.java.diagnostics.visualizer.parser.vgc.converters.GCNumberConverter;
             import com.java.diagnostics.visualizer.parsers.Parser;
             import com.java.diagnostics.visualizer.properties.OutputProperties;
             import com.java.diagnostics.visualizer.sources.Source;
             import java.io.BufferedReader;
             import java.io.IOException;
             import java.io.InputStreamReader;
             import java.io.PrintWriter;
             import java.io.StringWriter;
             import java.util.ArrayList;
             import java.util.Calendar;
             import java.util.HashMap;
             import java.util.logging.Level;
             import java.util.logging.Logger;
             import java.util.regex.Matcher;
             import java.util.regex.Pattern;
             
             public class InstanceI5ClassicParser
               extends VGCPlainTextParser
             {
               private static final Pattern DATE_PATTERN = Pattern.compile("START TIMESTAMP=([0-9][0-9])/([0-9][0-9])/([0-9][0-9][0-9][0-9]) ([0-9][0-9]):([0-9][0-9]):([0-9][0-9])\\.([0-9][0-9][0-9])");
               
               private static final SourceDataFactory SOURCE_DATA_FACTORY = SourceDataFactory.getFactory();
               private final Logger LOGGER = LogFactory.getTrace(Parser.class);
               
               private static final Logger TRACE = LogFactory.getTrace(InstanceI5ClassicParser.class);
               
               private boolean absoluteTime = false;
               private ArrayList chartData;
               private int chartDataIndex = 0;
               private int lowestCycleNumber = 2147483647;
               private int lowestCycleNumberEntry = 0;
               
               private long currentTime;
               
               private String nextLine;
               
               private SourceData sourceData;
               private XDataAxis xAxis;
               private GCNumberConverter gcNumberConverter;
               private YDataAxis heapAxis;
               private YDataAxis numberAxis;
               private YDataAxis timeAxis;
               private TupleDataBuilder cycleTimes;
               private TupleDataBuilder markGlobalsTimes;
               private TupleDataBuilder sync1Times;
               private TupleDataBuilder sync12Times;
               private TupleDataBuilder sync2Times;
               private TupleDataBuilder sync2ATimes;
               private TupleDataBuilder asyncHandshakeTimes;
               private TupleDataBuilder asyncFinishTimes;
               private TupleDataBuilder finishTimes;
               private TupleDataBuilder sweepTimes;
               private TupleDataBuilder usedHeap;
               private TupleDataBuilder freeHeap;
               private TupleDataBuilder heapSize;
               private TupleDataBuilder segmentsDeleted;
               private TupleDataBuilder unloadedClasses;
               private TupleDataBuilder gcInterval;
               private static final String CYCLE = "Cycle";
               private static final String TIME_START = "Time:Start";
               
               protected boolean isTimeStampRelative()
               {
                 return false;
               }
               
               public SourceData parse(Source source, OutputProperties properties) throws GCAndMemoryVisualizerException
               {
                 TRACE.entering(this.className, "parse");
                 
                 try
                 {
                   createTuples(source, properties);
                   
                   String variantIdentifier = source.getVariantIdentifier();
                   this.sourceData = 
                     SOURCE_DATA_FACTORY.createSourceData(variantIdentifier);
                   
                   trace("Ready to open input");
                   BufferedReader reader = new BufferedReader(new InputStreamReader(
                     source.getStream()));
                   
                   this.chartData = new ArrayList(300);
                   
                   String line;
                   do
                   {
                     line = readLine(reader);
                     if (line.trim().startsWith("OPTION ABSOLUTE_TIME")) {
                       this.absoluteTime = true;
                       trace("Absolute time specified");
                     }
                   } while (!
                   
                     line.trim().startsWith("******** BEGIN DUMP"));
                   
                   readStructuredData(reader);
                   
                   long lastTime = 0L;
                   while (reader.ready()) {
                     trace("Ready to read an entry");
                     
                     HashMap entryData = parseEntry(reader, properties);
                     if (entryData == null)
                       break;
                     if (tracing()) {
                       trace("Entry " + this.chartDataIndex + " parsed");
                     }
                     this.chartData.add(entryData);
                     if (entryData.containsKey("Cycle")) {
                       int cycleNum = Integer.parseInt(
                         (String)entryData.get("Cycle"));
                       if (cycleNum < this.lowestCycleNumber) {
                         this.lowestCycleNumber = cycleNum;
                         this.lowestCycleNumberEntry = this.chartDataIndex;
                       }
                     }
                     this.chartDataIndex += 1;
                   }
                   trace("Input source processing complete");
                   int nextEntry = this.lowestCycleNumberEntry;
                   do {
                     HashMap entryData = (HashMap)this.chartData.get(nextEntry);
                     
                     if (entryData.containsKey("Time:Start")) {
                       this.currentTime = Long.parseLong(
                         (String)entryData.get("Time:Start"));
                     } else {
                       throw new GCAndMemoryVisualizerException(
                         "Could not find Time:Start");
                     }
                     if (lastTime == 0L) {
                       lastTime = this.currentTime;
                     }
                     this.xAxis.setX(this.currentTime);
                     
                     int cycleNumber = -1;
                     if (entryData.containsKey("Cycle")) {
                       cycleNumber = Integer.parseInt(
                         (String)entryData.get("Cycle"));
                       this.gcNumberConverter.addPoint(this.xAxis.getSequenceUID(), 
                         cycleNumber);
                     }
                     long interval = this.currentTime - lastTime;
                     addDataPoint(this.gcInterval, interval);
                     conditionallyAddNumericPoint(this.segmentsDeleted, entryData, 
                       "SegmentsDeleted");
                     conditionallyAddNumericPoint(this.unloadedClasses, entryData, 
                       "CollectedClasses");
                     conditionallyAddNumericPoint(this.cycleTimes, entryData, 
                       "Duration:Cycle");
                     conditionallyAddNumericPoint(this.markGlobalsTimes, entryData, 
                       "Duration:MarkGlobals");
                     conditionallyAddNumericPoint(this.sync1Times, entryData, 
                       "Duration:Sync1");
                     conditionallyAddNumericPoint(this.sync12Times, entryData, 
                       "Duration:Sync1->Sync2");
                     conditionallyAddNumericPoint(this.sync2Times, entryData, 
                       "Duration:Sync2");
                     conditionallyAddNumericPoint(this.sync2ATimes, entryData, 
                       "Duration:Sync2->Async");
                     conditionallyAddNumericPoint(this.asyncHandshakeTimes, entryData, 
                       "Duration:AsyncHandshake");
                     conditionallyAddNumericPoint(this.asyncFinishTimes, entryData, 
                       "Duration:Async->FinishTrace");
                     conditionallyAddNumericPoint(this.finishTimes, entryData, 
                       "Duration:FinishTrace");
                     conditionallyAddNumericPoint(this.sweepTimes, entryData, 
                       "Duration:Sweep");
                     
                     conditionallyAddNumericPoint(this.usedHeap, entryData, 
                       "Size:Heap:End");
                     conditionallyAddNumericPoint(this.freeHeap, entryData, 
                       "Size:Free:End");
                     
                     conditionallyAddNumericPoint(this.heapSize, entryData, 
                       "Size:Total:End");
                     lastTime = this.currentTime;
                     if (tracing()) {
                       trace("Finished writing entry for cycle #" + cycleNumber);
                     }
                     nextEntry++;
                     if (nextEntry >= this.chartDataIndex) {
                       nextEntry = 0;
                     }
                   } while (nextEntry != this.lowestCycleNumberEntry);
                   
                   this.sourceData.addData(this.gcInterval, DataLevel.VARIANT);
                   this.sourceData.addData(this.segmentsDeleted, DataLevel.VARIANT);
                   this.sourceData.addData(this.unloadedClasses, DataLevel.VARIANT);
                   this.sourceData.addData(this.cycleTimes, DataLevel.VARIANT);
                   this.sourceData.addData(this.markGlobalsTimes, DataLevel.VARIANT);
                   this.sourceData.addData(this.sync1Times, DataLevel.VARIANT);
                   this.sourceData.addData(this.sync12Times, DataLevel.VARIANT);
                   this.sourceData.addData(this.sync2Times, DataLevel.VARIANT);
                   this.sourceData.addData(this.sync2ATimes, DataLevel.VARIANT);
                   this.sourceData.addData(this.asyncHandshakeTimes, DataLevel.VARIANT);
                   this.sourceData.addData(this.asyncFinishTimes, DataLevel.VARIANT);
                   this.sourceData.addData(this.finishTimes, DataLevel.VARIANT);
                   this.sourceData.addData(this.sweepTimes, DataLevel.VARIANT);
                   this.sourceData.addData(this.freeHeap, DataLevel.VARIANT);
                   this.sourceData.addData(this.heapSize, DataLevel.VARIANT);
                   
                   if (!this.absoluteTime) {
                     this.xAxis.updateNormalisation(this.sourceData);
                   }
                   
                   trace("Parser output written");
                 } catch (GCAndMemoryVisualizerException ex) {
                   throw ex;
                 } catch (IOException ex) {
                   this.LOGGER.log(Level.SEVERE, " -- IOException while parsing source: ", 
                     ex);
                   throw new GCAndMemoryVisualizerException(ex);
                 } catch (Throwable ex) {
                   this.LOGGER.log(Level.SEVERE, " -- Exception while parsing source: ", 
                     ex);
                   StringWriter stringWriter = new StringWriter();
                   PrintWriter printWriter = new PrintWriter(stringWriter);
                   ex.printStackTrace(printWriter);
                   throw new GCAndMemoryVisualizerException("Caught:\n" + 
                     stringWriter.toString());
                 }
                 TRACE.exiting(this.className, "parse");
                 return this.sourceData;
               }
               
               private void readStructuredData(BufferedReader reader) throws IOException {
                 String line;
                 do {
                   line = readLine(reader);
                 } while (!
                 
                   line
                   .trim()
                   .equals(
                   "GARBAGE COLLECTION CYCLE INFORMATION.  DURATION TIMES IN MILLISECONDS:"));
                 do {
                   line = readLine(reader);
                 } while (!
                 
                   line
                   .trim()
                   .equals(
                   "GARBAGE COLLECTION CYCLE INFORMATION.  DURATION TIMES IN MILLISECONDS:"));
               }
               
               private HashMap parseEntry(BufferedReader reader, OutputProperties properties) throws IOException
               {
                 HashMap result = new HashMap();
                 
                 String line = readLine(reader).trim();
                 if (line.trim().startsWith("******** END DUMP")) {
                   return null;
                 }
                 int[] cursor = new int[1];
                 cursor[0] = 0;
                 String value = nextValue(line, cursor);
                 result.put("Cycle", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:Cycle", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:EmptyMarkSet", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:Sync1", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:Sync1->Sync2", value);
                 value = nextValue(line, cursor);
                 
                 line = readLine(reader).trim();
                 cursor[0] = 0;
                 value = nextValue(line, cursor);
                 result.put("Duration:Sync2", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:Sync2->Async", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:AsyncHandshake", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:Async->FinishTrace", value);
                 
                 line = readLine(reader).trim();
                 cursor[0] = 0;
                 value = nextValue(line, cursor);
                 result.put("Duration:MarkGlobals", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:FinishTrace", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:ReferenceObject", value);
                 value = nextValue(line, cursor);
                 result.put("Duration:Sweep", value);
                 
                 line = readLine(reader).trim();
                 
                 if (line.startsWith("FIND DELETABLE")) {
                   line = readLine(reader).trim();
                 }
                 cursor[0] = 0;
                 value = nextValue(line, cursor);
                 result.put("Size:Heap:Start", value);
                 value = nextValue(line, cursor);
                 long longHeapEnd = Long.parseLong(value);
                 result.put("Size:Heap:End", value);
                 int timePos = line.indexOf("START TIMESTAMP=");
                 String timeLine = line.substring(timePos);
                 long longTime = getTime(timeLine);
                 result.put("Time:Start", Long.toString(longTime));
                 
                 line = readLine(reader).trim();
                 cursor[0] = 0;
                 value = nextValue(line, cursor);
                 result.put("Size:Free:Start", value);
                 value = nextValue(line, cursor);
                 long longFreeEnd = Long.parseLong(value);
                 result.put("Size:Free:End", value);
                 
                 result.put("Size:Total:End", Long.toString(longHeapEnd + longFreeEnd));
                 
                 line = readLine(reader).trim();
                 cursor[0] = 0;
                 value = nextValue(line, cursor);
                 result.put("CollectedClasses", value);
                 
                 line = readLine(reader);
                 line = readLine(reader);
                 if (line.trim().startsWith("REUSE SEGMENTS DELETED")) {
                   cursor[0] = 0;
                   value = nextValue(line, cursor);
                   result.put("SegmentsDeleted", value);
                   line = readLine(reader);
                 } else {
                   result.put("SegmentsDeleted", "0");
                 }
                 readLine(reader);
                 
                 return result;
               }
               
               private String readLine(BufferedReader reader) throws IOException {
                 if (this.nextLine == null) {
                   this.nextLine = readRawLine(reader);
                 }
                 String line = this.nextLine;
                 this.nextLine = readRawLine(reader);
                 if (line.trim().endsWith("+")) {
                   line = line.substring(0, line.lastIndexOf('+'));
                   line = line + this.nextLine;
                   this.nextLine = readRawLine(reader);
                 }
                 return line.trim().toUpperCase();
               }
               
               private String readRawLine(BufferedReader reader) throws IOException {
                 String line;
                 do {
                   line = reader.readLine();
                 } while ((line != null) && (
                   line.trim().startsWith("DISPLAY/ALTER/DUMP")));
                 return line;
               }
               
               private String nextValue(String line, int[] cursor)
               {
                 int position = line.indexOf('=', cursor[0]);
                 if (position == -1)
                   return null;
                 int space = line.indexOf(' ', position);
                 if (space == -1)
                   space = line.length();
                 String value = line.substring(position + 1, space);
                 cursor[0] = (space + 1);
                 return value;
               }
               
               private long getTime(String line)
               {
                 Matcher matcher = DATE_PATTERN.matcher(line);
                 matcher.find();
                 int month = Integer.parseInt(matcher.group(1));
                 int day = Integer.parseInt(matcher.group(2));
                 int year = Integer.parseInt(matcher.group(3));
                 int hour = Integer.parseInt(matcher.group(4));
                 int minute = Integer.parseInt(matcher.group(5));
                 int second = Integer.parseInt(matcher.group(6));
                 long ms = Integer.parseInt(matcher.group(7));
                 
                 Calendar cal = Calendar.getInstance();
                 cal.set(year, month, day, hour, 0, 0);
                 
                 long msFlaky = cal.getTimeInMillis();
                 
                 long hours = (msFlaky + 1800000L) / 3600000L;
                 
                 ms = ((hours * 60L + minute) * 60L + second) * 1000L + ms;
                 return ms;
               }
               
               private void conditionallyAddNumericPoint(TupleData tupleData, HashMap entryData, String id)
               {
                 if (entryData.containsKey(id)) {
                   addNumericPoint(tupleData, (String)entryData.get(id));
                 } else {
                   this.LOGGER.log(Level.SEVERE, "ID not found:" + id);
                 }
               }
               
               private void addNumericPoint(TupleData tupleData, String value) {
                 addDataPoint(tupleData, Long.parseLong(value));
               }
               
               private void addDataPoint(TupleData tupleData, long value) {
                 tupleData.addDataPoint(value, "");
               }
               
               private void createTuples(Source source, OutputProperties properties)
                 throws GCAndMemoryVisualizerException
               {
                 this.gcNumberConverter = new GCNumberConverter();
                 this.xAxis = VGCAxes.prepareXAxis(source, this.gcNumberConverter, properties);
                 
                 this.heapAxis = VGCAxes.prepareHeapAxis(properties);
                 this.numberAxis = VGCAxes.prepareNumberAxis(properties);
                 this.timeAxis = VGCAxes.prepareTimeAxis(properties);
                 
                 this.segmentsDeleted = 
                   createTuple("I5ClassicLabels.segments.deleted", this.xAxis, this.numberAxis);
                 
                 this.unloadedClasses = 
                   createTuple("VGCLabels.classes.unloaded", this.xAxis, this.numberAxis);
                 
                 this.cycleTimes = 
                   createPauseTuple("I5ClassicLabels.total.cycle.times", this.xAxis, this.timeAxis);
                 
                 this.markGlobalsTimes = 
                   createPauseTuple("I5ClassicLabels.time.taken.to.scan.roots", this.xAxis, this.timeAxis);
                 
                 this.sync1Times = createPauseTuple("I5ClassicLabels.sync1", this.xAxis, this.timeAxis);
                 
                 this.sync12Times = 
                   createPauseTuple("I5ClassicLabels.sync1.to.sync2", this.xAxis, this.timeAxis);
                 
                 this.sync2Times = createPauseTuple("I5ClassicLabels.sync2", this.xAxis, this.timeAxis);
                 
                 this.sync2ATimes = 
                   createPauseTuple("I5ClassicLabels.sync2.to.async", this.xAxis, this.timeAxis);
                 
                 this.asyncHandshakeTimes = 
                   createPauseTuple("I5ClassicLabels.async.handshake", this.xAxis, this.timeAxis);
                 
                 this.asyncFinishTimes = 
                   createPauseTuple("I5ClassicLabels.async.to.finish.trace", this.xAxis, this.timeAxis);
                 
                 this.finishTimes = 
                   createPauseTuple("I5ClassicLabels.finish.trace", this.xAxis, this.timeAxis);
                 
                 this.sweepTimes = createPauseTuple("VGCLabels.sweep.times", this.xAxis, this.timeAxis);
                 
                 this.usedHeap = 
                   createHeapTuple("I5ClassicLabels.used.heap.after.collection", this.xAxis, this.heapAxis);
                 
                 this.freeHeap = 
                   createHeapTuple("VGCLabels.free.flat.heap", this.xAxis, this.heapAxis);
                 
                 this.heapSize = createHeapTuple("VGCLabels.flat.heap.size", this.xAxis, this.heapAxis);
                 
                 this.gcInterval = createTuple("VGCLabels.trigger.intervals", this.xAxis, this.timeAxis);
                 
                 TupleMetaData cycleTimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData markGlobalsTimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX, TupleMetaData.TableField.TOTAL });
                 TupleMetaData sync1TimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData sync12TimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData sync2TimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData sync2ATimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData asyncHandshakeTimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData asyncFinishTimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData finishTimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData sweepTimesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX, TupleMetaData.TableField.TOTAL });
                 TupleMetaData usedHeapMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData freeHeapMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData heapSizeMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 TupleMetaData segmentsDeletedMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX, TupleMetaData.TableField.TOTAL });
                 TupleMetaData unloadedClassesMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX, TupleMetaData.TableField.TOTAL });
                 TupleMetaData gcIntervalMetaData = new TupleMetaData(
                   TupleMetaData.TableType.ARITHMETIC, new TupleMetaData.TableField[] { TupleMetaData.TableField.MEAN, 
                   TupleMetaData.TableField.MIN, TupleMetaData.TableField.MAX });
                 
                 this.cycleTimes.setTupleMetaData(cycleTimesMetaData);
                 this.markGlobalsTimes.setTupleMetaData(markGlobalsTimesMetaData);
                 this.sync1Times.setTupleMetaData(sync1TimesMetaData);
                 this.sync12Times.setTupleMetaData(sync12TimesMetaData);
                 this.sync2Times.setTupleMetaData(sync2TimesMetaData);
                 this.sync2ATimes.setTupleMetaData(sync2ATimesMetaData);
                 this.asyncHandshakeTimes.setTupleMetaData(asyncHandshakeTimesMetaData);
                 this.asyncFinishTimes.setTupleMetaData(asyncFinishTimesMetaData);
                 this.finishTimes.setTupleMetaData(finishTimesMetaData);
                 this.sweepTimes.setTupleMetaData(sweepTimesMetaData);
                 this.usedHeap.setTupleMetaData(usedHeapMetaData);
                 this.freeHeap.setTupleMetaData(freeHeapMetaData);
                 this.heapSize.setTupleMetaData(heapSizeMetaData);
                 this.segmentsDeleted.setTupleMetaData(segmentsDeletedMetaData);
                 this.unloadedClasses.setTupleMetaData(unloadedClassesMetaData);
                 this.gcInterval.setTupleMetaData(gcIntervalMetaData);
               }
               
               private TupleDataBuilder createTuple(String label, XDataAxis xAxis, YDataAxis yAxis)
               {
                 AxisPair axisPair = factory.createAxisPair(xAxis, yAxis);
                 return factory.createTupleData(label, Messages.getString(label), 
                   axisPair);
               }
               
               private TupleDataBuilder createHeapTuple(String label, XDataAxis xAxis, YDataAxis yAxis)
               {
                 AxisPair axisPair = heapFactory.createAxisPair(xAxis, yAxis);
                 return heapFactory.createTupleData(label, Messages.getString(label), 
                   axisPair);
               }
               
               private TupleDataBuilder createPauseTuple(String label, XDataAxis xAxis, YDataAxis yAxis)
               {
                 AxisPair axisPair = pauseFactory.createAxisPair(xAxis, yAxis);
                 return pauseFactory.createTupleData(label, Messages.getString(label), 
                   axisPair);
               }
               
               private boolean tracing() {
                 return this.LOGGER.isLoggable(Level.FINE);
               }
               
               private void trace(String message) {
                 this.LOGGER.log(Level.FINE, message);
               }
             }


